home *** CD-ROM | disk | FTP | other *** search
/ Light ROM 1 / LIGHT-ROM 1 (Amiga Library Services)(1994).iso / ffdisks / d880.lha / Oberon / O3Demo1.lzh / ReadMe < prev    next >
Text File  |  1993-01-14  |  73KB  |  1,789 lines
  1.                                                               13-December-1992
  2.  
  3.  
  4.               Amiga Oberon-2 3.00 (limited Version)
  5.  
  6.  
  7. Introduction:
  8.  
  9.  
  10.   This is a freely distributable demo version of a powerful Oberon-2 compiler.
  11.   Oberon-2 is a modern object-oriented programming language. It's the latest
  12.   development of Prof.  Dr. Niklaus Wirth and Prof. Dr. Hanspeter Mössenböck
  13.   of the Institute for Computer Systems, Swiss Federal Institute of
  14.   Technology (ETH Zürich). The language is the result of a project to improve
  15.   the performance and to reduce the complexity of Modula-2. Primarily, the
  16.   concept of type extension has been added to Oberon, providing object-
  17.   oriented programming facilities comparable to those of the languages
  18.   Smalltalk and C++.  At the same time, Oberon retains the notational
  19.   conventions of Modula-2 and Pascal.
  20.  
  21.   This compiler offers some features seldom found in other compilers:
  22.  
  23.     - The compiler performs only a single pass, thereby providing fast
  24.       translations.  Still, the code produced is short and fast, because the
  25.       compiler applies carefully selected optimizations.
  26.   
  27.     - Memory usage is controlled by an incremental garbage-collector. It is
  28.       neither necessary nor possible to free allocated memory explicitly. The
  29.       garbage-collector inquires memory while the main program is running and
  30.       it frees unused objects automatically. This way you have the security
  31.       that your program is free of such dangerous bugs as using memory, that
  32.       has been freed.
  33.  
  34.     - Object files are BLink-compatible. You may include object files written
  35.       in different languages, eg. assembler modules, to your program.
  36.  
  37.     - Unused code is removed by the linker ensuring small executables.
  38.  
  39.     - Programs are very robust at run time, because the compiler employs
  40.       a lot of runtime checks to trap errors of many kinds. In most cases,
  41.       run time failures do not result in a system failure; rather, they are
  42.       captured by the run time system.
  43.  
  44.     - In order to permit access to the functions and resources of the Amiga
  45.       operating system, the language has been extended by Amiga specific
  46.       types and functions.
  47.  
  48.     - A big library of modules is supplied with the compiler and many library
  49.       modules are available within the AMOK-PD-Series (currently 81 disks).
  50.  
  51.     - Any executable Oberon-2 program may be made resident.
  52.   
  53.     - Setting one single compiler option causes the compiler to create fully
  54.       reentrant (pure) programs.
  55.  
  56.     - Alternatively, the compiler may create optimized code for the processors
  57.       68000, 68010, 68020 and 68030 and for the FPU 68881/68882. The FPU is
  58.       fully supported, even its trigonometric functions (SIN, LOGN,..) may be
  59.       used directly.
  60.  
  61.     - The compiler supports conditional compilation.
  62.  
  63.     - Symbol files may be kept resident in memory to reduce compilation time.
  64.  
  65.     - A powerful Runtime-Debugger is available for Amiga Oberon-2.
  66.  
  67.   This Oberon-2-System is an ideal tool to develop small and large
  68.   applications for the amiga effectively. Code re-use based on module
  69.   libraries is supported via the object-oriented features of the language,
  70.   and any object previously defined may easily be adapted to new problems.
  71.  
  72.  
  73. Limitations of the demo version:
  74.  
  75.   This version of the compiler shall enable you to translate a few Oberon-2
  76.   programs and to investigate some of the compiler's features.  However, this
  77.   is not the full version.  A few restrictions have been built into the
  78.   compiler which will prevent you from using it over an extended time period.
  79.   The idea is to encourage you to purchase the full version (see details
  80.   below) if you believe it is worth it to keep me alive.  The following
  81.   paragraphs list the restrictions build into this demo version.
  82.  
  83.     - Only a small subset of the module library and of the AmigaOS interface
  84.       modules are provided.
  85.  
  86.     - The documentation is short and in many ways insufficient.
  87.  
  88.     - The compiler refuses to do its job on mondays.
  89.   
  90.     - The source text of each module must not be longer then 10 KB.
  91.   
  92.     - The program code per module must not be longer then 5 KB.
  93.   
  94.     - No module may have more than 3 KB of global variables.
  95.   
  96.     - For each module, the maximum number of imported modules is restricted
  97.       to seven.
  98.   
  99.     - The editor cannot handle more than 200 lines of text.
  100.   
  101.     - You are forced to use the small data model since the object files
  102.       supplied with this demo version are created using the small data model.
  103.  
  104.     - You may not disable garbage-collection because the supplied object
  105.       files are compiled using the garbage-collector.
  106.  
  107.     - Runtime-errors within programs written with this demo-version do not
  108.       yield an error message, they just lead to program termination.
  109.  
  110.     - No more than 50 menu selections may be done within the debugger.
  111.  
  112.  
  113.  
  114. The disks contain the following files:
  115.  
  116.   Disk 1: OberonDemo_3.0_Disk1
  117.   
  118.     ReadMe:           This file.
  119.  
  120.     Oberon-Report:    The Oberon-Report, a text describing the language
  121.                       oberon, written by N. Wirth of ETH Zürich
  122.   
  123.     ModulaToOberon:   The text "From Modula To Oberon", also from ETH Zürich.
  124.  
  125.     Oberon-2.txt:     Description of the language Oberon-2, written by H.
  126.                       Mössenböck, ETH Zürich
  127.  
  128.     Install:          Script-File for installation of the compiler
  129.   
  130.     Oberon:           The compiler, it translates source files to object
  131.                       and symbol files.
  132.   
  133.     OLink:            The linker, it puts together the object files and creates
  134.                       an executable program.
  135.   
  136.     OEd:              The editor.
  137.  
  138.     OEd_Keys.txt:     Textfile, describes OEd's keyboard settings
  139.  
  140.     OEd_Menu.txt:     Textfile, describes OEd's menu layout
  141.  
  142.     OEdRexxHelp.txt:  Text describing OEd's ARexx commands, this text is
  143.                       automatically displayed when HELP is pressed within OEd
  144.  
  145.     OErr:             This programs displays error messages created by the
  146.                       compiler if compilation failed.
  147.  
  148.     Path:             Textfile listing all paths for the compiler and linker
  149.                       to search for object and symbol files
  150.   
  151.     Error_Messages:   Text file containing the error messages displayed by OEd
  152.                       or OErr.
  153.  
  154.     ResidentManager:  This tool forces symbol files to be kept resident in
  155.                       memory once they've been loaded. This increases compile
  156.                       time on systems with slow harddisk or floppies.
  157.  
  158.     ResidentModules:  Textfile, contains the names of all modules whose symbol
  159.                       files should be kept resident. 'all' keeps all symbol
  160.                       files resident.
  161.  
  162.     ODebug:           The runtime debugger.
  163.   
  164.     Icons     (dir):  This drawer contains all icons used for the different
  165.                       kinds of files. They are used by the compiler, linker,
  166.                       etc.
  167.  
  168.     libs      (dir):  Necessary libraries:
  169.                         oberonsupport.library       (reads symbol files)
  170.                         garbagecollector.library    (the garbage-collector)
  171.                         arp.library                 (filerequester for WB1.3)
  172.   
  173.     ExeIcon:         Program similar to IconX
  174.   
  175.   Disk 2: OberonDemo_3.0_Disk2
  176.   
  177.     Examples (dir):   Some Oberon-2 examples.
  178.   
  179.         Tetriz:   Small Workbench-Game
  180.   
  181.     sym, obj  (dir):  Symbol- and Objectfiles of supplied modules.
  182.   
  183.     Definitions (dir):  Definition files of some of the supplied
  184.     modules.
  185.  
  186.     All programs of these two disks have been written in Oberon-2 and
  187.     compiled using Amiga Oberon-2. They all may be made resident (pure).
  188.  
  189.  
  190. Used filename extensions:
  191.  
  192.   The Oberon-Files use the following filename-extensions:
  193.  
  194.     Sourcecode                            '.mod'
  195.     Symbolfile                            '.sym'
  196.     Objectfile                            '.obj'
  197.     Objectfile using small data model     '.objs'
  198.     Referencefile used by ODebug          '.ref'
  199.     Executable program                      ''
  200.  
  201.  
  202. Installation of the compiler:
  203.  
  204.   The compiler may easily be installed by double clicking the Icon 'Install'
  205.   of the first disk. This installation script copies the required libraries
  206.   to your LIBS: drawer and assign the logical director OBERON: to the first
  207.   Oberon disk.
  208.  
  209.   If you plan to use the Compiler from within your Shell, you should extend
  210.   your 'S:Shell-Startup' by the line 'PATH OBERON: ADD'.
  211.  
  212.  
  213. The Editor OEd:
  214.  
  215. This Editor has been developed  in  Oberon-2 especially for Oberon-2 program
  216. development.  It may easily  be  used  with  the  mouse,  and  provides  the
  217. following features:
  218.  
  219.   -  manipulation of multiple source text files
  220.   -  Oberon-2 syntax checking
  221.   -  interactive compilation, linkage, and program execution
  222.   -  interactive error reporting
  223.   -  powerful ARexx interface
  224.  
  225. Starting OEd:
  226.  
  227.   Simply double-click OEd's icon, or type "OEd" in  a  CLI  window.   You  may
  228.   specify text file names as arguments for OEd, or, from  the  Workbench,  you
  229.   may make a multiple selection of text files, and then  double- click  OEd' s
  230.   icon while the Shift key is pressed.  In this case,  each  of  the  selected
  231.   text files will automatically be loaded into a separate window.
  232.  
  233.   From the CLI:
  234.  
  235.     OEd {-{i|t#|x#|y#|w#|h#|d#|s|l|u#|a}}
  236.         [c-{s|v|b|c|r|n|o|t|p|m|d|1|2|3|8|i|g|y}] {<Text>}
  237.  
  238.   Options are introduced by a minus sign ('-').  The symbol '#'  represents  a
  239.   decimal number.
  240.  
  241.     -i       generate icons
  242.     -t#      set tab width (default = 2)
  243.     -x#,-y#  top left position of OEd windows
  244.     -w#,-h#  width and height of OEd windows
  245.     -d#      depth of OEd screen (default = 2)
  246.     -s       open on separate screen (default = Workbench)
  247.     -l       open interlace screen
  248.     -u#      max. size of undo buffer (default = 50; see below)
  249.     -a       activate 'Auto Uppercase'; see below
  250.  
  251.     'c-...'  introduces the options for the Compiler and the Linker.  Their
  252.              meanings and defaults are identical to those of the Compiler (see
  253.              below).
  254.  
  255.   Example:
  256.  
  257.     OEd -sy11d1u100 Test.mod
  258.  
  259.   This will open a window for the source text 'Test.mod' on a  separate,  two-
  260.   colour OEd screen immediately under  the  screen' s  title  bar.   The  undo
  261.   buffer can accept up to 100 entries.
  262.  
  263.   From the Workbench:
  264.  
  265.   Before starting OEd from the Workbench, options may  be  specified  via  the
  266.   tool  types  using  Workbench  function ' Information'   or '  Info'.    OEd
  267.   understands the following tool types:
  268.  
  269.     ICONS             generate / don't generate icons (TRUE/FALSE)
  270.     TABULATOR         tab width
  271.     LEFTEDGE, TOPEDGE top left position of OEd windows
  272.     WIDTH, HEIGHT     width and height of OEd windows
  273.     DEPTH             depth of OEd screen
  274.     SCREEN            open on separate screen (TRUE) or on
  275.                       Workbench screen (FALSE)
  276.     INTERLACE         open interlace screen
  277.     MAXUNDO           max. size of undo buffer (see below)
  278.     AUTOUPPERCASE     enable / disable (TRUE/FALSE) Auto Uppercase; see below
  279.  
  280. OEd Usage:
  281.  
  282.   The title bar of an OEd  window  serves  as  a  status  line.   It  displays
  283.   important information, eg error messages.  Normally, it  contains  something
  284.   like
  285.   
  286.     col: 8 line: 85 of 88 chgs: 205 file: Test.mod
  287.  
  288.   Here, the numbers after col: and line:, respectively,  specify  the  current
  289.   cursor position (column 8 in line 85 in this case).   The  number  after  of
  290.   defines the total number of lines in  this  text  file.   The  number  after
  291.   chgs: specifies the number of text modifications since  the  file  has  been
  292.   saved for the last time.  Finally, the name of the file  displayed  in  this
  293.   window is given by the string following file:.
  294.  
  295.   The gadgets on the right hand side of an  OEd  window  allow  easy  movement
  296.   through  the  text  file.   The  large  proportional  gadget  displays   the
  297.   relative position and size of the visible text, as  compared  to  the  whole
  298.   text file.  It may be used  for  fast  movement  in  both  directions.   The
  299.   arrow gadgets underneath are provided for line-by-line movement.
  300.  
  301. Key Definitions and Combinations:
  302.  
  303.   Cursor keys (arrow keys):
  304.  
  305.   With these keys, you can move the cursor to any text position.
  306.  
  307.   Using the horizontal arrow keys together with  an  Alt  key  allows  you  to
  308.   move from one word to the next or previous word, while  the  vertical  arrow
  309.   keys together with  an  Alt  key  provide  forward  and  backward  movements
  310.   through pages.
  311.  
  312.   Pressing a Shift key as a qualifier permits jumping to the beginning  or  to
  313.   the end, respectively, of the current line (horizontal arrow  keys),  or  of
  314.   the whole text file (vertical arrow keys).
  315.  
  316.   The Control (Ctrl) key together with a vertical arrow key scrolls  the  text
  317.   upwards or downwards, respectively, without  changing  the  relative  cursor
  318.   position inside the window.
  319.  
  320.   Backspace:
  321.  
  322.   Using this key, you may delete the character to  the  left  of  the  current
  323.   cursor position.  Backspace is ignored, if the cursor is positioned  at  the
  324.   beginning of a line.  Qualifying it with an Alt key  results  in  the  whole
  325.   word to the left of the cursor being deleted.  Pressing  the  Backspace  and
  326.   Control keys simultaneously allows you  to  delete  all  characters  in  the
  327.   current line which are on the left of the current cursor position.
  328.  
  329.   Del:
  330.  
  331.   The Del  key  is  used  to  delete  the  character  at  the  current  cursor
  332.   position.  At the end  of  a  line,  pressing  the  Del  key  results  in  a
  333.   concatenation of the current line and the next line.   You  may  delete  the
  334.   word to the right of the cursor by pressing one  of  the  Alt  and  the  Del
  335.   keys at the same time.  Together with the Control  key,  all  characters  to
  336.   the right of the current cursor position, including  the  character  at  the
  337.   current cursor position, are deleted.  Pressing one of  the  Shift  and  the
  338.   Del keys simultaneously deletes the whole line.
  339.  
  340.   Return:
  341.  
  342.   With the Return key, you can insert a new line immediately  below  the  line
  343.   containing the cursor.  Also, the cursor is moved to the first  position  of
  344.   the new line.  Pressing a Shift and the Return  keys  simultaneously  splits
  345.   the current line into two lines at the current cursor position.
  346.  
  347.   TAB:
  348.  
  349.   Pressing the Tab key takes you to the next, or if one of the Shift  keys  is
  350.   pressed simultaneously, to the previous, tab  stop.   The  distance  between
  351.   tab stops is normally two character positions.   The  tab  distance  may  be
  352.   modified at OEd startup, using option '-t#'.
  353.  
  354.   Escape (Esc):
  355.  
  356.   This key reduces the active OEd window to its minimum size and  puts  it  in
  357.   the background.  In this way, you can  avoid  cluttering  the  screen.   The
  358.   Escape key is a toggle, so pressing it again brings the  active  OEd  window
  359.   back to its original size and position.
  360.   
  361.   Pressing one of the Shift and the Escape keys simultaneously allows  you  to
  362.   cycle through all of  the  OEd  windows.   OEd  windows  are  activated  and
  363.   brought to the foreground in sequence, even if OEd has been  activated  more
  364.   than once.  This function allows  you  to  move  from  one  text  window  to
  365.   another, without using the mouse.
  366.  
  367.   Function Keys F1..F5:
  368.  
  369.   Pressing a Shift key and one of  these function keys  simultaneously  allows
  370.   you to associate the current line with  a  marker.   If  the  same  function
  371.   key (without a Shift key) is pressed subsequently,  the  cursor  jumps  back
  372.   to the line previously marked.
  373.  
  374.   Amiga + '0'..'9','A'..'Z':
  375.  
  376.   Most of the menu items (see below) may also be selected  by  pressing  the
  377.   right Amiga key and a letter or digit key simultaneously.
  378.  
  379. The Mouse:
  380.  
  381.   You may move the cursor to any text position by  moving  the  mouse  pointer
  382.   there and clicking the left mouse button.
  383.  
  384.   To mark a block of text with the mouse, keep the left mouse  button  pressed
  385.   and move horizontally or vertically until you have reached the  end  of  the
  386.   block.  Now release the mouse button.  There  are  various  operations  with
  387.   blocks of text; see further below.
  388.  
  389. The Menus:
  390.  
  391.   The Project Menu:
  392.  
  393.   Load  (Amiga + 'L'):
  394.  
  395.   This function opens a file requester for entering a new file name.   If  the
  396.   file currently displayed was modified, but  has  not  been  saved  yet,  you
  397.   will be asked if you  wish  to  save  the  current  file,  before  the  file
  398.   requester is displayed.
  399.  
  400.   New Window (Amiga + 'W'):
  401.  
  402.   This function opens a new, empty window in which another text  file  may  be
  403.   displayed.
  404.  
  405.   Save (Amiga + 'S'):
  406.  
  407.   The text file is saved under the name displayed in the status  line.   If  a
  408.   file with the same name already exists, it is given a  new  name  first ( by
  409.   appending '.bak').  Consequently, if the system crashes while  the  file  is
  410.   being saved, the old file still  exists.   Only  after  the  file  has  been
  411.   saved successfully, the old file is removed.
  412.  
  413.   Save As (Amiga + 'V'):
  414.  
  415.   This function opens a file requester, so that you  can  save  the  currently
  416.   active text file under any name of your choice.
  417.  
  418.   Save block (Amiga + 'O'):
  419.  
  420.   The block previously selected with the mouse or the  block  menu  is  saved.
  421.   A file requester is displayed allowing you to  specify  a  file  name.  This
  422.   function has no effect if  the  marked  block  is  smaller  than  one  line.
  423.  
  424.   Insert File (Amiga + 'I'):
  425.  
  426.   This function inserts a text file before the  line  containing  the  cursor.
  427.   A file requester is displayed allowing you to specify a file name.
  428.  
  429.   Print (Control + 'P'):
  430.  
  431.   Sends the text to the printer using the settings selected with  the  printer
  432.   preferences program.
  433.  
  434.   Print Block (Control + 'B'):
  435.  
  436.   Sends the selected block to the printer.
  437.  
  438.   Print As (Control + 'I'):
  439.  
  440.   A requester allowing you to select a left  margin,  print  quality ( NLQ  or
  441.   Draft), pitch (normal or condensed) and line  spacing ( 6  or  8  lines  per
  442.   inch) is brought up. Pressing the Return key  or  selecting  the  OK  gadget
  443.   starts printing the file using the selected style.
  444.  
  445.   Print Block As (Control + 'O'):
  446.  
  447.   This function is similar to Print As with the difference that  the  selected
  448.   block is printed.
  449.  
  450.   Hide (Control + ESC):
  451.  
  452.   The currently active OEd-Window will be  closed ( hidden).  It  may  be  re-
  453.   opened using Reveal. At least one window has to remain open.
  454.  
  455.   Reveal (Control + 'V'):
  456.  
  457.   A requester is displayed. You may  chose  one  opened  text  file  with  the
  458.   mouse or the the vertical arrow keys. Selecting the Return  key  or  the  OK
  459.   gadget will open that text's window, if it was closed using Hide,  else  its
  460.   window will jump in front of all other windows.
  461.  
  462.   Screen Mode (Control + 'D'):
  463.  
  464.   This function will only work on Amigas with AmigaOS 2.0 installed.  It  will
  465.   open a requester to select the display  mode  OEd  should  use.  Information
  466.   about the selected mode will be saved in a file named ' Oberon: ScreenMode'.
  467.   This mode will be used the next time OEd is started on a separate screen.
  468.  
  469.   About (Amiga + 'J'):
  470.  
  471.   Information about the version and the author of OEd is displayed.
  472.  
  473.   Quit (Amiga + 'Q'):
  474.  
  475.   The active window is closed.  If the text file was  modified,  you  will  be
  476.   asked if you wish to save the file.  Any  other  windows  previously  opened
  477.   via New Window, or corresponding parameters at OEd start, remain opened.
  478.  
  479.   The Search Menu:
  480.  
  481.   Find (Amiga + 'F'):
  482.  
  483.   A window is opened containing a string gadget where you may enter  a  search
  484.   string.  Three further gadgets specify search modes: case  sensitive  versus
  485.   not case sensitive, forward versus backwards,  and  character  by  character
  486.   versus word by word.  A word-by- word  search  is  limited  to  letters  and
  487.   digits.
  488.  
  489.   After pressing the Return key or the OK gadget, the  text  is  searched  for
  490.   the string,  starting  at  the  current  cursor  position.   If  the  string
  491.   exists, then the cursor is positioned  at  its  beginning.   Otherwise,  the
  492.   screen will flash.
  493.  
  494.   Next (Amiga + 'N'):
  495.  
  496.   This function searches  forward  for  the  next  occurrence  of  the  string
  497.   previously specified with Find.
  498.  
  499.   Previous (Amiga + 'P'):
  500.  
  501.   This function searches backwards for  the  next  occurrence  of  the  string
  502.   previously specified with Find.
  503.  
  504.   FindRep (Amiga + 'G'):
  505.  
  506.   FindRep is similar to  Find.   It  opens  a  window  containing  two  string
  507.   gadgets, where a search string and a replacement string,  respectively,  may
  508.   be entered.  There is another gadget which allows  you  to  specify  whether
  509.   all occurrences of the search string shall be  substituted ( all),  or  only
  510.   the next one (single).   Substitution  commences  when  the  Return  key  is
  511.   pressed in the second string gadget, or when the OK gadget is selected.
  512.  
  513.   If all was selected, the cursor jumps to the next occurrence of  the  search
  514.   string.  Then a small window is displayed which lets you decide  whether  to
  515.   perform  the  current  substitution ( yes!),  or   to   skip   the   current
  516.   substitution ( no!),  or  to   perform   the   current   and   all   further
  517.   substitutions automatically (all), or to  terminate  substitution  (Cancel).
  518.   Instead of clicking a gadget, you may press one of the keys y, n, a, or  C (
  519.   first letter of each option).
  520.  
  521.   NextRep (Amiga + 'R'):
  522.  
  523.   This function searches  forward  for  the  next  occurrence  of  the  search
  524.   string previously specified  with  FindRep,  and  substitutes  it  with  the
  525.   replacement string.
  526.  
  527.   PrevRep (Amiga + 'H'):
  528.  
  529.   This function searches backwards for  the  next  occurrence  of  the  search
  530.   string previously specified  with  FindRep,  and  substitutes  it  with  the
  531.   replacement string.
  532.  
  533.   Find Word (Alt + 'F'):
  534.  
  535.   This function takes the word at the current position as  search  string  and
  536.   searches forward the next occurrence of this string.
  537.  
  538.   The Block Menu:
  539.  
  540.   Begin (Amiga + 'B'):
  541.  
  542.   This function removes the marking of a previously  defined  block,  if  any,
  543.   and defines the line containing the cursor as the block start.
  544.  
  545.   End (Amiga + 'E'):
  546.  
  547.   The end of block mark is set to the line currently  containing  the  cursor.
  548.   The block thus defined is highlighted.  In  the  following,  this  block  is
  549.   referred to as the marked  block.   A  block  may  alternatively  be  marked
  550.   using the mouse (also refer to section "The Mouse" above).
  551.  
  552.   If this menu item is selected while a  marked  block  already  exists,  then
  553.   the block is extended up to and including the current line.
  554.  
  555.   If End is selected while the cursor is within  the  line  previously  marked
  556.   using Begin, a horizontal block that consists of a part  of  the  line  will
  557.   be marked.
  558.  
  559.   Copy Block (Amiga + 'Y'):
  560.  
  561.   This  function  inserts  a  copy  of  the  marked  block  before  the   line
  562.   containing the cursor or at  the  cursor  position  if  it' s  a  horizontal
  563.   block.  The original block remains unchanged.
  564.  
  565.   Move (Amiga + 'M'):
  566.  
  567.   This function inserts a copy of the marked block at the cursor  position  as
  568.   it's done by Copy Block. Additionally, the original block is removed.
  569.  
  570.   Delete (Amiga + 'D'):
  571.  
  572.   This function deletes the marked block.
  573.  
  574.   Cut (Alt + 'X'):
  575.  
  576.   The marked block is removed and put in the clipboard's buffer.
  577.  
  578.   Copy (Alt + 'C'):
  579.  
  580.   A copy of the marked block is put in the clipboard's  buffer.  The  original
  581.   block remains unchanged.
  582.  
  583.   Paste (Alt + 'V'):
  584.  
  585.   The block previously put into the clipboard's  buffer  is  inserted  at  the
  586.   current cursor position.
  587.  
  588.   TAB right (Control + 'R'):
  589.  
  590.   The  marked  block  is  moved to  the  right  by  the  specified  tab  width
  591.   (normally 2).
  592.  
  593.   TAB left (Control + 'L'):
  594.  
  595.   The marked block is moved to the left by the specified tab width.
  596.  
  597.   Unmark (Amiga + 'U'):
  598.  
  599.   This function unmarks a block.  The block itself  is  not  changed;  rather,
  600.   the highlighting is removed, and the block is therefore no longer marked.
  601.  
  602.   The Special Menu:
  603.  
  604.   Enter Rexx Cmd (Control + 'E'):
  605.  
  606.   A window  is  opened  which  allows  you  to  type  a  short  ARexx  command
  607.   sequence.  Pressing the Return key or clicking  the  OK  gadget  causes  the
  608.   command sequence to be  executed  immediately,  provided,  of  course,  that
  609.   ARexx is properly installed.
  610.  
  611.   The command sequence is executed asynchronously, ie you can  continue  using
  612.   OEd while the ARexx program is running.
  613.  
  614.   Example:
  615.  
  616.     DO i=1 TO 10; 'write' i; 'return'; END
  617.  
  618.   This command sequence generates the numbers 1 through 10,  and  stores  each
  619.   of them in a separate line of the active OEd window.
  620.  
  621.   Execute Rexx Cmd (Control + 'X'):
  622.  
  623.   The ARexx command sequence entered via Enter Rexx Cmd is executed.
  624.  
  625.   Stop Rexx (HI) (Control + 'C'):
  626.  
  627.   This function allows you to stop an ARexx program  previously  started  with
  628.   Enter/Execute Rexx Cmd or a function key.   In  order  to  accomplish  this,
  629.   the  program ' HI' ( also  refer  to  ARexx  User' s  Reference  Manual)  is
  630.   executed.  'HI' must be located in logical device 'C:' or 'REXXC:'.
  631.  
  632.   Stop Rexx is a  useful  mechanism  to  interrupt  infinite  loops  in  ARexx
  633.   command sequences.
  634.  
  635.   Goto Line (Control + 'G'):
  636.  
  637.   A requester is brought up which allows you to type the number  of  the  line
  638.   the cursor should go to.  Selecting the Return key or  the  OK  gadget  will
  639.   move the cursor to that line.
  640.  
  641.   Goto Last Change (Control + 'A'):
  642.  
  643.   The cursor will be set to the position at  which  the  last  change  in  the
  644.   text file has been  made.   This  is  often  useful  after  you  have  moved
  645.   through the text to look something up and want to  return  to  the  location
  646.   you are currently editing.
  647.  
  648.   Matching Bracket (Control + 'H'):
  649.  
  650.   This command may  be  executed  when  the  cursor  is  positioned  over  a
  651.   parenthesis ("(" or ")"),  bracket ("["  or "]")  or  brace ("{"  or "}").
  652.   The text file will be scanned forward or backwards for  the  corresponding
  653.   parenthesis. The direction  in  which  the  cursor  is  moved  depends  on
  654.   whether it's over an opening or a closing parenthesis.
  655.  
  656.   If there is no corresponding parenthesis, the screen will flash.
  657.  
  658.   Change Case (Alt + 'A');
  659.  
  660.   Changes the case to the character at the current position.
  661.  
  662.   Undo (Control + '<'):
  663.  
  664.   Repeated application of this function allows you  to  undo  the  effects  of
  665.   previous operations in reverse order.  Hereby, it does not matter  in  which
  666.   way the text was modified before (eg via typing,  searching  and  replacing,
  667.   block operations etc).
  668.  
  669.   The size of the undo buffer specified  at  OEd  start  determines  how  many
  670.   previous operations may  be  undone.   Also,  different  operations  require
  671.   quite different amounts of space: Eg if a block is  deleted,  it  is  stored
  672.   in its entirety.
  673.  
  674.   Undo decreases the number of changes indicated in the status  line  by  one.
  675.   If undo is executed straight after a save operation, the number  of  changes
  676.   becomes negative, because the text kept by the  Editor  is  older  than  the
  677.   text last saved.
  678.  
  679.   A block mark may be removed by the undo function.
  680.  
  681.   Redo (Control + '>'):
  682.  
  683.   Redo can only be executed straight after  an  undo  operation.   It  repeats
  684.   the operation  previously  undone,  and  increases  the  number  of  changes
  685.   indicated in the status line by one.
  686.  
  687.   Undo All (Control + 'U'):
  688.  
  689.   All changes since the last save  operation  are  undone.   However,  if  the
  690.   undo buffer size is not large enough, only the operations stored in  it  are
  691.   undone.
  692.  
  693.   Redo All (Control + 'W'):
  694.  
  695.   Redo All can only  be  executed  straight  after  Undo  or  Undo  All.   All
  696.   operations previously undone are re-executed.
  697.  
  698.   Clear All Undos:
  699.  
  700.   This function should only be used if  the  available  amount  of  memory  is
  701.   very low.  The contents of the undo buffer are  cleared,  and  their  memory
  702.   is released. Thereafter, the changes made before selecting Clear  All  Undos
  703.   may no more be undone.
  704.  
  705.   Undelete Line (Alt + 'L'):
  706.  
  707.   Inserts the line deleted using <Shift> plus <Del> at the current position.
  708.  
  709.   The Oberon Menu:
  710.  
  711.   The functions of this menu  support  the  development  of Oberon-2 programs.
  712.   Thus, they cannot reasonably be applied to other types of text files.
  713.  
  714.   Parse (Amiga + 'A'):
  715.  
  716.   The text file is parsed, ie this function investigates if the  text  adheres
  717.   to the syntax rules of the Oberon-2 language, or of  the extensions provided
  718.   by this Compiler.  If a syntax error is found, the cursor is  moved  to  its
  719.   location, and a short error message is displayed in the status line.
  720.  
  721.   Parsing is much faster than compilation.  It  is  therefore  recommended  to
  722.   make use of this function before compiling the text.  In this  way,  obvious
  723.   syntax  errors  like  omitted  END  statements  or   inconsistent   use   of
  724.   parentheses may be detected, before they  cause  the  Compiler  to  generate
  725.   consequential error messages.
  726.  
  727.   Note that parsing does not detect semantic errors, like  incompatible  types
  728.   etc.
  729.  
  730.   Compile (Amiga + 'C'):
  731.  
  732.   This function starts the Oberon-2 Compiler with  the  name  of the currently
  733.   active text file as a parameter.  The Compiler makes use of  the  text  file
  734.   stored in memory, which therefore does not need to be saved to  disk  before
  735.   compilation.  It is not possible to continue editing during compilation.
  736.   
  737.   The Compile function as well as the next four functions  further  below  all
  738.   assume that the commands CD, STACK, PATH, and RUN exist  in  logical  device
  739.   C:.  If you  have  enough  memory,  then  you  should  make  these  commands
  740.   resident.
  741.   
  742.   Also, logical device T: should exist so that OEd can create a temporary file.
  743.  
  744.   Link (Amiga + 'K'):
  745.  
  746.   This function starts OLink in order to link the program previously compiled.
  747.  
  748.   Make (Control + 'M'):
  749.  
  750.   This function starts OMake with the name of the currently active  text  file
  751.   as parameter.
  752.  
  753.   Execute (Amiga + 'X'):
  754.  
  755.   This function executes the program previously  linked.   A  Workbench  start
  756.   without parameters is simulated.
  757.  
  758.   Compiler Options (Control + 'T'):
  759.  
  760.   This function allows you to set the options used by conditional compilation.
  761.  
  762.   Next Error (Amiga + 'T'):
  763.  
  764.   If the Compiler detected any errors, then they  may  be  viewed  using  this
  765.   function.  Next Error always reports the next  error  to  the  right  of  or
  766.   under the current cursor position.  The error message is  displayed  in  the
  767.   status line.  If there are  no  more  errors,  then  the  message ' No  more
  768.   errors' is displayed.
  769.  
  770.   First Error (Amiga + 'Z'):
  771.  
  772.   This  function  moves  the  cursor  to  the  position  of  the  first  error
  773.   encountered by the Compiler, and reports it in the status  line.   If  there
  774.   were no compilation errors, then the message 'No errors' is displayed.
  775.  
  776.   Reload Errorfile (Control + 'Q'):
  777.  
  778.   This function forces OEd to reload the error file created by  the  compiler.
  779.   This is necessary when the text  hasn' t  been  changed  but  it  has  been
  780.   recompiled and a new error file has been created.
  781.                  
  782.   The Options Menu:
  783.  
  784.   This  menu  allows  you  to  set  various  compiling,  and  linking  options
  785.   interactively.
  786.  
  787.   The Settings Menu:
  788.  
  789.   This  menu  allows  you  to  set  various  editing options interactively.
  790.  
  791.   Insert (Amiga + '.'):
  792.  
  793.   If Insert is selected, then the Editor  is  in  insert  mode,  otherwise  in
  794.   overwrite mode.
  795.  
  796.   Layout Mode (Amiga + '-'):
  797.  
  798.   Selects layout mode. In layout mode the  cursor  stays  within  the  current
  799.   line if you move it to the left at the beginning or to the right at the  end
  800.   of the line.
  801.  
  802.   Auto Uppercase (Amiga + ','):
  803.  
  804.   This option, if selected, tells OEd to automatically  convert  all  reserved
  805.   words and standard identifiers to  upper  case.  This  way  you  may  type '
  806.   module' and 'integer' in stead of 'MODULE' and 'INTEGER'.
  807.  
  808.   Create Icons? (Amiga + '0'):
  809.  
  810.   This option, if selected, permits automatic generation of icons.
  811.  
  812.   Set Script Flag?
  813.  
  814.   If selected, the script flag will be set while saving the text.
  815.  
  816. ARexx Interface:
  817.  
  818.   OEd includes a powerful ARexx interface  providing  full  control  over  the
  819.   Editor more than 140 commands. Of course, this interface can only be used on
  820.   Amigas where ARexx is properly installed,  and  the  program ' RexxMast'  is
  821.   running in the background.
  822.  
  823.   You must be familiar with the Rexx Language and the ARexx  Manual  in  order
  824.   to be able to exploit the possibilities of OEd's ARexx interface.
  825.  
  826.   OEd's ARexx port is simply called 'OEd'.  There is only a single  port  even
  827.   if OEd is running more than once.   The  commands  sent  to  this  port  are
  828.   broadcasted to all OEd processes, but picked up only by  the  process  which
  829.   owns the currently active window.  If no window is  currently  active,  then
  830.   the commands are sent to  the  OEd  process  which  owned  the  most  recent
  831.   active window.
  832.  
  833.   A detailed description of OEd's ARexx commands may be found in the manual to
  834.   Amiga Oberon-2. For a short summary, read the file 'OEdRexxHelp.txt'.
  835.  
  836. Menu and keyboard settings:
  837.  
  838.   OEd's menu and  keyboard  setting  are  freely  configurable  by  the  files
  839.   OEdMenu.txt and OEdKeys.txt. For more information  you' ll  have  to  obtain
  840.   the Manual.
  841.  
  842.  
  843. The compiler Oberon:
  844.  
  845. The program 'Oberon' is the actual  compiler  which  performs  most  of  the
  846. work: It receives the source  files  developed  with  OEd ( or  a  different
  847. ASCII  editor),  and  it  generates  an  external  symbol  file   containing
  848. information about all objects  exported  by  the  compiled  module,  and  an
  849. object file containing the generated object code, ie the program.
  850.  
  851. If the Compiler detects  errors  in  the  source  file,  then  it  does  not
  852. generate the external symbol and object files.   Rather,  it  generates  and
  853. stores information about error locations  and  corresponding  error  message
  854. numbers in a separate error file.
  855.  
  856.   Compiler Usage:
  857.  
  858.   From the Editor:
  859.  
  860.   Under OEd, the Compiler may simply be started  by  selecting  the ' Compile'
  861.   function.
  862.  
  863.   From the CLI:
  864.  
  865.   First, use the CD command  to  make  the  directory  containing  the  source
  866.   files, or the 'txt' subdirectory, the current directory.
  867.   
  868.   Usually, the Compiler needs a stack area larger than 4K  bytes.   Therefore,
  869.   you should set the stack size to a value between 10,000 and 20,000 bytes.
  870.  
  871.   Now the Compiler may be started using the following syntax:
  872.  
  873.     Oberon { [-svbcrnotpzmd1238igy]
  874.            [SET | CLEAR <option>]
  875.            <source text> }
  876.  
  877.   <source text> stands for the text file to  be  compiled.   The  extension '.
  878.   mod' may be omitted. If the source text is located  in  subdirectory ' txt',
  879.   it will be picked up from there.  Thus, instead of
  880.  
  881.     Oberon txt/Test.mod ,
  882.  
  883.   you can simply type
  884.  
  885.     Oberon Test .
  886.  
  887.   You may specify several source text files; in this case, the files  will  be
  888.   compiled in sequence.
  889.  
  890.   Options always refer to all source  text  files  specified  on  their  right
  891.   hand side.  They have the following effects:
  892.  
  893.     Option  Effect
  894.     
  895.     '-s'    disable stack control
  896.     '-v'    disable overflow control
  897.     '-b'    disable scope control
  898.     '-c'    disable case index control
  899.     '-r'    disable return control
  900.     '-n'    disable nil pointer control
  901.     '-o'    enable odd address control
  902.     '-t'    disable type control
  903.     '-p'    disable register parameters and variables
  904.     '-z'    set local variables to zero
  905.     '-m'    use small code model
  906.     '-d'    use small data model
  907.     '-1'    generate code specifically for 68010 processor
  908.     '-2'    generate code specifically for 68020 processor
  909.     '-3'    generate code specifically for 68030 processor
  910.     '-8'    generate code for floating point unit (68881/68882)
  911.     '-i'    generate icons
  912.     '-g'    generate debugging information
  913.     '-y'    do not generate new symbol file
  914.  
  915.   All object files supplied with this demo version are compiled using the
  916.   small data model. This is why you have to use this data model, too. You
  917.   have to specify the option '-d' when starting the compiler.
  918.  
  919.   Providing an option several times will toggle its function on  or  off  each
  920.   time it's given.
  921.  
  922.   SET <option> and/or CLEAR <option> allow you to set  and/ or  clear  options
  923.   for conditional compilation.
  924.  
  925.  
  926.   Options only refer to the source text files to the right.  Example:
  927.  
  928.     Oberon -sv Prog1 -bs Prog2
  929.  
  930.   In this case, Prog1 will be compiled  without  stack  and  without  overflow
  931.   control, and Prog2 without scope control and without  overflow  control  but
  932.   with stack control.
  933.  
  934.   If you start the Compiler without any parameters, it will  prompt  you  with
  935.   'in>', and  wait  for  you  to  type  a  source  text  file  name.  You  may
  936.   alternatively skip compilation altogether simply by pressing the Return  key.
  937.  
  938.   From the Workbench:
  939.  
  940.   If you wish to start the Compiler from the Workbench, then  you  must  first
  941.   shift-select all source text files, and then double-click on  the  Compiler'
  942.   s icon.
  943.  
  944.   You should  not  start  the  Compiler  from  the  Workbench  without  shift-
  945.   selecting source files first, unless you want the Compiler to  store  object
  946.   and symbol files in its home directory.  This is normally not what you want.
  947.  
  948.   Tool types are available for all CLI options discussed above.  They  may  be
  949.   specified or modified by selecting  Workbench  menu  item  'Information'  or
  950.   'Info' after selecting the Compiler's icon.  The  following  paragraph lists
  951.   all tool types and their corresponding CLI options:
  952.  
  953.     Tool Type   Corresponding CLI Option
  954.     
  955.     STACKCHK     -s
  956.     OVFLCHK      -v
  957.     RANGECHK     -b
  958.     CASECHK      -c
  959.     RETURNCHK    -r
  960.     NILCHK       -n
  961.     ODDCHK       -o
  962.     TYPECHK      -t
  963.     AUTOREGPARS  -p
  964.     CLEARVARS    -z
  965.     SMALLCODE    -m
  966.     SMALLDATA    -d
  967.     MC68010      -1
  968.     MC68020      -2
  969.     MC68030      -3
  970.     MC68881      -8
  971.     ICONS        -i
  972.     DEBUG        -g
  973.     NEWSYMBOLS   -y
  974.  
  975.   Compiler Operation:
  976.  
  977.   The Compiler keeps you informed about the files  which  it  is  manipulating
  978.   at any point  in  time,  by  displaying ' - < file  name>'  whenever  it  is
  979.   reading a file, and ' + <file name>' whenever it is generating a file.
  980.  
  981.   First, the external symbol files of all imported modules  are  loaded.   For
  982.   each of these modules, the Compiler displays ' - XXX.sym'.  As soon  as  all
  983.   import modules are loaded, the Compiler starts generating  code.   For  each
  984.   kilobyte of code generated, a dot is displayed.
  985.  
  986.   If the program currently being  compiled  makes  use  of  REAL  or  LONGREAL
  987.   numbers, then the external symbol  files  of  the  mathematics  modules  are
  988.   also loaded.
  989.  
  990.   Once the source text is compiled, the Compiler  checks  if  a  new  external
  991.   symbol file must be generated.  In order to achieve this, it reads  the  old
  992.   external symbol file, if it exists,  and  compares  it  to  the  one  to  be
  993.   generated.  If it detects differences, then  it  generates  a  new  external
  994.   symbol file called  'XXX.sym', or ' sym/ XXX. sym',  if  subdirectory ' sym'
  995.   exists.
  996.  
  997.   Subsequently, the code  is  optimized  in  about  two  to  eight  additional
  998.   passes.  In this phase,  the  Compiler  displays ' optimizing ...'  and  the
  999.   number of bytes saved.  Eventually, the optimized code  is  saved  in  Amiga
  1000.   compatible object code format under the name 'XXX.obj', or ' obj/ XXX. obj',
  1001.   if subdirectory 'obj' exists.
  1002.  
  1003.   Finally, the sizes of the code, data, and BSS segments are displayed.
  1004.  
  1005.   If any errors are detected during compilation, file XXX.modE  is  generated,
  1006.   and appropriate entries are made.  The error messages  may  subsequently  be
  1007.   viewed using OEd or OErr.
  1008.  
  1009.   Compilation Example:
  1010.  
  1011.     in> Demo
  1012.     - Demo.mod
  1013.     - OBERON:sym/Graphics.sym
  1014.     - OBERON:sym/Hardware.sym
  1015.     - OBERON:sym/Exec.sym
  1016.     - OBERON:sym/Intuition.sym
  1017.     - OBERON:sym/KeyMap.sym
  1018.     - OBERON:sym/Timer.sym
  1019.     - OBERON:sym/InputEvent.sym
  1020.     - OBERON:sym/Dos.sym
  1021.     - OBERON:sym/OberonLib.sym
  1022.     .. - sym/Demo.sym
  1023.     
  1024.     optimizing ...   80
  1025.     optimizing ...   10
  1026.     optimizing ...    0
  1027.     + obj/Demo.obj
  1028.     CODE:  2368  DATA:     0  BSS:   1760
  1029.  
  1030.   This reflects a compilation of the program 'Demo.mod'.
  1031.  
  1032. Special features of the compiler:
  1033.  
  1034.   Amiga Oberon-2 supports three different set types: SHORTSET, SET and
  1035.   LONGSET. Their sizes are 8, 16 and 32 bits, respectively.
  1036.  
  1037.   Following the BEGIN-statement-sequence, every module may have a CLOSE-
  1038.   statement-sequence. These statements are executed on termination of the
  1039.   program. They should be used to free resources allocated by the module.
  1040.  
  1041.   Pointer types may be declared as 'UNTRACED POINTER TO ...'. These pointers
  1042.   are not traced by the garbage-collector. They may eg. be used to reference
  1043.   structures of the AmigaOS.
  1044.  
  1045.   Pointer types may be declared as 'BPOINTER TO ...'. These pointers may be
  1046.   used to directly access some structures used by the Dos-Library.
  1047.  
  1048.   To access C-Structures within Oberon-2 programs you have to use the type
  1049.   STRUCT. STRUCT is used similarly to RECORD. Compared to RECORDs, STRUCTs
  1050.   contain no hidden type-information.
  1051.  
  1052.   Amiga Oberon-2 knows a new standard procedure DISPOSE(). It may be used
  1053.   to free memory allocated for an UNTRACED POINTER using the standard
  1054.   procedure NEW().
  1055.  
  1056.   The module SYSTEM defines the type BYTE, ADDRESS and the procedures ADR,
  1057.   LSH, ROT, INLINE, REG, SETREG, VAL, INIT, TYPEDESC and ALLOCATE.
  1058.  
  1059.   Amiga Oberon-2 allows structured function results (arrays or records).
  1060.  
  1061.   You may directly access a function result with Amiga Oberon-2, so a call
  1062.   'Proc().x' is possible, if Proc() returns a pointer to a record with an
  1063.   element 'x'.
  1064.  
  1065.   Amiga Oberon-2 allows an arbitrary number of parameters for some routines
  1066.   of the AmigaOS:
  1067.  
  1068.     Dos.PrintF("a=%ld  b=%ld  c=%ld\n",a,b,c);
  1069.     Intuition.OpenWindowTags(newwindow,
  1070.                              Intuition.waWidth, 500,
  1071.                              Intuition.waHeight,200,
  1072.                              Intuition.Title,   SYSTEM.ADR("Tag-List-Demo"),
  1073.                              Utility.end);
  1074.  
  1075.  
  1076.   Compiler options:
  1077.  
  1078.   You may modify compiler options within comments. The options start with
  1079.   a dollar sign '$' followed by their name and one of the character '+',
  1080.   '-' or '='. '+' sets the option, '-' clears it and '=' resets it to the
  1081.   value before the last '+' or '-'.
  1082.   Example:
  1083.  
  1084.     (* $OvflChk- *)
  1085.       checksum := checksum + x;
  1086.     (* $OvflChk= *)
  1087.  
  1088.   Here overflow check is disabled for one statement and reset after this
  1089.   statement. You may specify the following options:
  1090.  
  1091.     Name           Opt Tool-Type Default  may be nested? relation
  1092.     
  1093.     StackChk       -s  STACKCHK  TRUE     yes
  1094.     OvflChk        -v  OVFLCHK   TRUE     yes
  1095.     RangeChk       -b  RANGECHK  TRUE     yes
  1096.     CaseChk        -c  CASECHK   TRUE     yes
  1097.     ReturnChk      -r  RETURNCHK TRUE     yes
  1098.     NilChk         -n  NILCHK    TRUE     yes
  1099.     OddChk         -o  ODDCHK    FALSE    yes
  1100.     TypeChk        -t  TYPECHK   TRUE     yes
  1101.     ClearVars      -z  CLEARVARS TRUE     yes
  1102.     Debug          -g  DEBUG     FALSE    yes
  1103.     EntryExitCode                TRUE     no             procedure
  1104.     CopyArrays                   TRUE     no             procedure
  1105.     SaveRegs                     FALSE    no             procedure
  1106.     SaveAllRegs                  FALSE    no             procedure
  1107.     DeallocPars                  TRUE     no             procedure
  1108.     Implementation               TRUE     no             module
  1109.     CodeChip                     FALSE    no             module
  1110.     VarsChip                     FALSE    no             module
  1111.     DataChip                     FALSE    no             module
  1112.  
  1113.  
  1114.   Conditional Compilation:
  1115.  
  1116.   When starting the compiler, you may set or clear options for conditional
  1117.   compilation using the shell arguments 'SET <option>' or 'CLEAR <option>',
  1118.   respectively. These Options may also be set within comments using
  1119.   (* $SET <option> *) or (* $CLEAR <option> *). You may ask the state of
  1120.   one of these options with '$IF <option>', '$IFNOT <option>', '$ELSE'
  1121.   and '$END'. Example: The module
  1122.  
  1123.     MODULE Test;
  1124.  
  1125.     IMPORT io;
  1126.  
  1127.     BEGIN
  1128.       (* $IF English *)
  1129.         io.WriteString("bye!");
  1130.       (* $ELSE *)
  1131.         io.WriteString("tschüß!");
  1132.       (* $END *)
  1133.       io.WriteLn;
  1134.     END Test.
  1135.  
  1136.   yields 'bye!' when compiled using 'Oberon SET English Test'. It prints
  1137.   'tschüß!' if the compiler was called  as 'Oberon CLEAR English Test'.
  1138.  
  1139.  
  1140. OLink:
  1141.  
  1142.   OLink links the object  files  create  by  the  compiler  to  an  executable
  1143.   program.
  1144.  
  1145.   If you are using the Workbench, you may start OLink by double  clicking  the
  1146.   icon of your program's main module object file.
  1147.  
  1148.   OLink's shell usage is:
  1149.  
  1150.     OLink [-smdai] <objectfile>
  1151.  
  1152.   <objectfile> is the name of the main module object file created by the
  1153.   compiler.
  1154.  
  1155.   The options have the following effects:
  1156.  
  1157.     -s   All hunks of same type should be merged
  1158.  
  1159.     -m   should be set when you are using the small code model
  1160.  
  1161.     -d   must be set when you are using the small data model
  1162.  
  1163.     -a   must be set when you are not using the garbage-collector
  1164.  
  1165.     -i   create icons
  1166.  
  1167.   This demo version only includes the object files for the small data model,
  1168.   you will have to set the option '-d' when linking a program.
  1169.  
  1170.  
  1171. OErr:
  1172.  
  1173.   You may use OErr to report errors detected by the Compiler.
  1174.  
  1175.   Usage:  OErr {source}.
  1176.  
  1177.  
  1178. ODebug:
  1179.  
  1180.   This  run-time  source-level  debugger  is  a  useful  tool  for  developing
  1181.   programs  with  the Amiga Oberon-2 System.   For  beginners,  it provides an
  1182.   insight  into  program execution, and for advanced software  developers,  it
  1183.   is indispensable.
  1184.  
  1185.   This debugger provides the same degree of luxury as a  language  interpreter
  1186.   for the Oberon-2 programmer.  Many functions are available  which support eg
  1187.   single step execution, investigation of  local  and  global  variables,  and
  1188.   setting breakpoints anywhere in the source text.
  1189.  
  1190.   Hardware Requirements:
  1191.  
  1192.   ODebug requires an Amiga Series Computer with a minimum of 1.5MB  of  memory
  1193.   and two floppy disk drives, or a hard disk drive.  For  the  development  of
  1194.   larger programs consisting of many different  modules,  more  memory  should
  1195.   be available.
  1196.  
  1197.   ODebug has been developed especially for use under  AmigaOS  2. 0,  but  may
  1198.   also be  used  under  AmigaOS  1. 2  or  1. 3  without  any  problems.   Its
  1199.   appearance under AmigaOS 2.0 is more attractive, though.
  1200.  
  1201.   Debugger Usage:
  1202.  
  1203.   First, all  modules  of  a  program  which  shall  be  displayed  under  the
  1204.   Debugger must be compiled with option '-g'.  If  you  intend  to  start  the
  1205.   Compiler from the editor OEd, you must first select  option  Debug ( Options
  1206.   menu).  In either case, the  Compiler  will  automatically  import  module '
  1207.   Debug' and generate special code for displaying compiled modules  under  the
  1208.   Debugger.   Furthermore,  the  Compiler  generates  reference  files (  with
  1209.   extension '.ref') containing additional, vital information for  ODebug.   If
  1210.   subdirectory 'ref' exists in the  current  directory,  the  reference  files
  1211.   will be stored in that subdirectory.
  1212.  
  1213.   After compilation of all modules, the program must  be  linked  with  OLink,
  1214.   just like a "normal" Oberon-2 program.
  1215.  
  1216.   From the CLI:
  1217.  
  1218.   Before starting ODebug,  you  should  increase  the  stack  size  by  typing
  1219.   'stack 20000'.  Subsequently, you should start the Debugger as a  background
  1220.   task (using the run command) in order  to  avoid  a ' hanging'  CLI  window.
  1221.   You may specify options, similar to those of the editor OEd:
  1222.  
  1223.     run ODebug {-{x#|y#|w#|h#|d#|s|l|p|r|c|o|1#|2#|3#|4#}}
  1224.  
  1225.   Character '#' stands for a decimal number.  The options have  the  following
  1226.   meanings:
  1227.  
  1228.     -x#, -y#  top left position of ODebug windows
  1229.     -w#, -h#  width and height of ODebug windows
  1230.     -s        open separate screen
  1231.     -l        open interlace screen
  1232.     -d#       screen depth (default = 2)
  1233.     -p        deactivate 'popup windows'
  1234.     -r        activate 'sort records'
  1235.     -c        activate 'close pointers'
  1236.     -o        do not open all source text windows automatically
  1237.     -1#, -2#  top left position of standby window
  1238.     -3#, -4#  width and height of standby window
  1239.  
  1240.   More details about the last four options can be found in the  section  about
  1241.   the Options menu.
  1242.  
  1243.   From the Workbench:
  1244.  
  1245.   From the Workbench, you may start  ODebug  simply  by  double- clicking  its
  1246.   icon.  Options may be specified via tool types.  They  may  be  modified  by
  1247.   selecting Workbench menu item 'Information' or 'Info'  after  selecting  the
  1248.   Debugger's icon:
  1249.  
  1250.     LEFTEDGE       left position of ODebug windows
  1251.     TOPEDGE        top position of ODebug windows
  1252.     WIDTH          width of ODebug windows
  1253.     HEIGHT         height of ODebug windows
  1254.     SCREEN         open on separate screen ('TRUE') or on Workbench screen
  1255.                    ('FALSE')
  1256.     INTERLACE      open interlace screen ('TRUE') non- interlace screen
  1257.                    ('FALSE')
  1258.     DEPTH          depth of ODebug screen
  1259.     POPUPWINDOWS   set ('TRUE') or clear ('FALSE') option 'popup windows'
  1260.     SORTRECORDS    set ('TRUE') or clear ('FALSE') option 'sort records'
  1261.     CLOSEPOINTERS  set ('TRUE') or clear ('FALSE') option 'close pointers'
  1262.     OPENSOURCES    open all source text windows at program start ('TRUE'), or
  1263.                    display only required source texts ('FALSE')
  1264.     STANDLEFTEDGE  left position of standby window
  1265.     STANDTOPEDGE   top position of standby window
  1266.     STANDWIDTH     width of standby window
  1267.     STANDHEIGHT    height of standby window
  1268.  
  1269.   The last four tool types refer directly  to  the  defaults  of  the  Options
  1270.   menu discussed further below.
  1271.  
  1272.   ODebug Operation:
  1273.  
  1274.   First, ODebug opens a small window  displaying  the  message " Please  start
  1275.   program compiled with option '- g'!".   Hence,  you  should  start  now  the
  1276.   executable program.  It does not matter whether you start it  from  the  CLI
  1277.   or from the  Workbench,  with  or  without  parameters.   As  soon  as  your
  1278.   program begins, the Debugger  closes  its  initial  window,  and,  for  each
  1279.   module compiled with option '-g',  opens  a  new  window  and  displays  the
  1280.   corresponding  source  text.   The  statement  about  to  be   executed   is
  1281.   highlighted.  The Debugger's menus now give you full  control  over  program
  1282.   execution: You can select single step execution, or you can run  a  part  of
  1283.   the program until certain  conditions  are  met  which  you  have  specified
  1284.   before.  Such conditions can be  given  as  breakpoints,  specific  variable
  1285.   values, or even as run time errors.
  1286.  
  1287.   When the initial window is displayed, you can leave the Debugger  simply  by
  1288.   selecting the window's close gadget.
  1289.  
  1290.   ODebug windows are equipped with proportional and  arrow  gadgets  at  their
  1291.   right and bottom borders, just like  Workbench  windows,  so  that  you  can
  1292.   display any part of the represented information.  This  window  organization
  1293.   is provided in a uniform way.
  1294.  
  1295.   Each window can be closed at any time by selecting its  close  gadget.   The
  1296.   Debugger remains active as long  as  at  least  one  window  displaying  the
  1297.   source text of a module is still opened.  Selection of the close  gadget  of
  1298.   the last source text window is treated  like  the  selection  of  the  Abort
  1299.   Debug option in the Project menu (see below).
  1300.  
  1301.   As soon as the program attempts to execute  a  statement  of  a  module,  of
  1302.   which the corresponding source text window has previously been  closed,  the
  1303.   window will be reopened.  This is the case eg  whenever  a  procedure  of  a
  1304.   different  module  is  called,  and  the  source  text  of  that  module  is
  1305.   currently not displayed.
  1306.  
  1307.   The Menus:
  1308.  
  1309.   The Project Menu:
  1310.  
  1311.   Abort Debug (Amiga + 'A'):
  1312.  
  1313.     The current program is terminated  immediately.   The Debugger deallocates
  1314.     all memory areas for the source texts and the reference files, and  closes
  1315.     all windows.  Subsequently, the  initial  window  is redisplayed, and  the
  1316.     Debugger waits until  the  next  program  is  started, or  until the  user
  1317.     decides to terminate the Debugger by selecting the initial window's  close
  1318.     gadget.
  1319.  
  1320.     The Abort Debug option does not automatically free resources, like windows
  1321.     or allocated memory.  The program currently being  debugged is responsible
  1322.     for this.
  1323.  
  1324.     If there are severe errors in a program's CLOSE part, Abort Debug may even
  1325.     lead to a system failure.
  1326.  
  1327.   Quit (Amiga + 'Q'):
  1328.  
  1329.     Quit terminates the current program, just like Abort  Debug. Subsequently,
  1330.     the Debugger itself is terminated,  too.   In  this  case, ODebug must  be
  1331.     restarted if you wish to debug another program.
  1332.  
  1333.   About:
  1334.  
  1335.     A window is opened displaying information about the version and the author
  1336.     of this Debugger.
  1337.  
  1338.   The Debug Menu:
  1339.  
  1340.   Step (Amiga + 'S', Space Bar):
  1341.  
  1342.     Step  executes  the  current,  highlighted  statement.   Subsequently, the
  1343.     logically following statement to be executed is highlighted, and selecting
  1344.     Step again will execute it etc.  If the current  statement  is a procedure
  1345.     call,  then  the  following  statement  is  the  first  statement  of that
  1346.     procedure, the text of which is then also displayed by the Debugger.
  1347.   
  1348.     This function allows you to work your  way  through  your  program step by
  1349.     step, and to detect errors and/or unwanted execution paths.
  1350.  
  1351.   Walk (Amiga + 'W'):
  1352.  
  1353.     Walk allows you to follow program execution in a  manner similar  to Step.
  1354.     However,  statements  are  highlighted   and   executed   automatically in
  1355.     sequence.  Between statements, the Debugger  pauses  for  0.2  seconds, so
  1356.     that you can easily follow program execution.
  1357.  
  1358.     You can interrupt Walk at  any  time  by  pressing  the  left mouse button
  1359.     whilst pointing to a window, or by selecting a menu item.
  1360.  
  1361.     Walk also terminates upon reaching a  breakpoint ( refer to  discussion of
  1362.     Breakpoint menu), or if  a  run- time  error  occurs.  In  either case,  a
  1363.     requester is displayed  providing  information  about  the reason  for the
  1364.     interrupt.
  1365.  
  1366.   Run (Amiga + 'R'):
  1367.  
  1368.     Run executes the program even faster than Walk, starting with  the current
  1369.     statement.  You cannot follow execution on-screen.  Run can be interrupted
  1370.     in exactly the same manner as Walk.
  1371.  
  1372.   Execute (Amiga + 'X'):
  1373.  
  1374.     Just  like  Step,  Execute  executes  the  current, highlighted statement.
  1375.     However,  execution  is  terminated  only  after  reaching   the textually
  1376.     following statement.  Thus, if the  highlighted  statement  is a procedure
  1377.     call, the whole procedure is executed, unless a  breakpoint is encountered
  1378.     or a run-time error occurs.  Similarly, if the current statement is a loop
  1379.     statement, the whole loop is executed.
  1380.  
  1381.     Like Walk and Run, Execute may be interrupted by  pressing  the left mouse
  1382.     button or selecting a menu item.  Also,  breakpoints  and  run-time errors
  1383.     terminate program execution.
  1384.  
  1385.   Run Quick (Amiga + 'K'):
  1386.  
  1387.     Often, a program which has been started by selecting  Run  is still fairly
  1388.     slow.   Run  Quick  allows  you  to  execute  a  program  faster, until  a
  1389.     breakpoint or a run-time error is encountered.
  1390.  
  1391.     Note, however, than Run Quick cannot be interrupted  by  pressing the left
  1392.     mouse button, or by selecting a menu item.  Furthermore, Run Quick ignores
  1393.     breakpoint expressions entered via option Add Expression of the Breakpoint
  1394.     menu.
  1395.  
  1396.     Run Quick can be used eg for fast execution of large  initialization parts
  1397.     of a program.  Make sure, though, that at least one breakpoint is defined,
  1398.     so that control is returned to the Debugger.
  1399.  
  1400.   Sprint (Amiga + 'I'):
  1401.  
  1402.     Sprint allows you to quickly find statements generating run-time errors.
  1403.  
  1404.     The overhead caused by the extensive checks performed when  the program is
  1405.     executed via Run, can dramatically slow  down  program  execution. Sprint,
  1406.     on the other hand, virtually executes the program in real time  mode. Note
  1407.     that Sprint is only terminated by run-time errors.   If  a  run-time error
  1408.     occurs, the statement causing it is highlighted.  Also,  Sprint allows you
  1409.     to investigate the values of global variables, but not of local variables,
  1410.     and the calling sequence of procedures cannot be inspected (see discussion
  1411.     of Variables menu).
  1412.  
  1413.     A program looping endlessly should not be started using Sprint, because it
  1414.     cannot be interrupted any more.
  1415.  
  1416.   Show Source (Amiga + 'H'):
  1417.  
  1418.     Windows displaying source  texts  can  be  closed  by  selecting the close
  1419.     gadget.  Also,  starting  ODebug  with  option '- o'  or  with  tool  type
  1420.     "OPENSOURCES" set to 'FALSE' prevents displaying all source texts.
  1421.  
  1422.     If you wish to investigate a source text which is not currently displayed,
  1423.     you can select Show Source.  A window is opened which allows you to select
  1424.     a module, either via double-click, or by clicking on  a  module name once,
  1425.     and selecting the 'ok' gadget.
  1426.  
  1427.     Now a corresponding window is opened,  or,  if  such  a  window is already
  1428.     open, it is activated and moved to the foreground.
  1429.  
  1430.   Show Statement (Amiga + 'N'):
  1431.  
  1432.     The gadgets at the bottom and right borders of  a  source  text window are
  1433.     provided for fast movement through the text.  If  you  are not  sure where
  1434.     exactly the current, highlighted  statement  is  located,  or  you wish to
  1435.     return to the current statement  as  fast  as  possible,  then select Show
  1436.     Statement.
  1437.  
  1438.     If the window associated with the source text  which  contains the current
  1439.     statement is not open, then it is opened automatically.
  1440.  
  1441.   The Breakpoint Menu:
  1442.  
  1443.     A statement displayed  in  boldface  represents  a  breakpoint.  A program
  1444.     started  with  Walk,  Run,  or  Execute  is  interrupted  just before  the
  1445.     execution of a statement marked in that way.
  1446.     
  1447.     In addition to breakpoints at fixed positions in  the  text, this Debugger
  1448.     allows you to specify boolean expressions as interrupt criteria.
  1449.  
  1450.   Set (Amiga + 'T'):
  1451.  
  1452.     Set  allows  you  to  specify  a  breakpoint.   First,  you  must select a
  1453.     statement with the mouse by pressing  the  left  mouse  button. Note  that
  1454.     statements may be nested.  Eg the line
  1455.  
  1456.       IF a>b THEN a := b END;
  1457.  
  1458.     consists  of  an  assignment  statement (' a :=  b')  and   the  whole  IF
  1459.     statement.  If you define 'a := b' as a  breakpoint,  the  program is only
  1460.     interrupted if condition 'a>b' holds.  However, if you define the whole IF
  1461.     statement as a  breakpoint,  the  program  is  interrupted  each time this
  1462.     statement is reached.
  1463.  
  1464.     The reserved words END, CLOSE, UNTIL, ELSE,  and  ELSIF, and delimiter '|'
  1465.     may also be selected to specify a breakpoint.   In  this  way, you  can eg
  1466.     interrupt a procedure after execution of its  last  statement in order  to
  1467.     investigate the values of the local  variables  just  before leaving their
  1468.     scope (also see Variables menu).
  1469.  
  1470.     Defining keyword END in the IF statement above as a  breakpoint would lead
  1471.     to a program interrupt straight after execution of 'a := b'.
  1472.  
  1473.   Remove (Amiga + 'M'):
  1474.  
  1475.     To remove a breakpoint, first select the corresponding  statement with the
  1476.     left mouse button, and then select Remove.
  1477.  
  1478.     Alternatively, you can simply double-click on  a  statement  with the left
  1479.     mouse button to set a  breakpoint,  or  to  remove  it,  if this statement
  1480.     already defines a breakpoint.
  1481.  
  1482.   Add Expression (Amiga + 'D'):
  1483.  
  1484.     This menu item allows you to  define  conditions  for program interruption
  1485.     via boolean expressions.  A window with a  string  gadget  is opened where
  1486.     you can enter an arbitrary boolean expression in  Oberon-2 syntax. You can
  1487.     make use of all variables and constants of  this  module and  all imported
  1488.     modules which are visible  in  the  current  context.   The  result of the
  1489.     expression must be of type BOOLEAN.  If it becomes TRUE,  then the program
  1490.     is interrupted.
  1491.  
  1492.     Example:
  1493.  
  1494.       (x>Window.width) OR (y>Graphics.gfx.normalDisplayRows)
  1495.  
  1496.     This expression will interrupt the program if x  becomes  greater than the
  1497.     width of window Window, or if y becomes greater than the maximum intuition-
  1498.     supported viewport height.  In this case, the variables  x, y, and  Window
  1499.     must be defined in  the  current  module,  which  also  must import module
  1500.     Graphics.
  1501.  
  1502.     Pressing the Return key in  the  string  gadget  will  display the current
  1503.     value of the boolean expression.
  1504.  
  1505.     The boolean gadget No break on error/Break on error allows you  to specify
  1506.     whether an error on evaluating  the  boolean expression  shall lead  to  a
  1507.     program interrupt  or  not.   If  Break  on  error  is selected, then  the
  1508.     expression above would also cause a program interrupt  if eg  Window = NIL
  1509.     holds.  Likewise, calling a procedure would lead to an interrupt, if x and
  1510.     y are local variables, and hence no longer visible.
  1511.  
  1512.     Selecting 'ok' stores the expression as  a  new  interrupt  criterion. You
  1513.     may specify any number of criteria.
  1514.  
  1515.     Selecting 'Cancel' allows you to  leave  the  window  without changing the
  1516.     list of interrupt criteria.
  1517.  
  1518.     If a program is interrupted  because  a  boolean  expression becomes TRUE,
  1519.     then a window is opened giving details about the  cause  of the interrupt,
  1520.     and allowing you  to  remove  the  criterion  from the list  (by selecting
  1521.     'remove'), or to keep it (by selecting 'Cancel').
  1522.  
  1523.   Change Expression (Amiga + 'J'):
  1524.  
  1525.     This menu item allows  you  to  modify  an  interrupt criterion previously
  1526.     specified via Add Expression.  First, a  window  is opened which  displays
  1527.     all currently existing criteria.  Selecting one of  them causes  the  same
  1528.     window to be opened as for Add Expression.
  1529.  
  1530.   Remove Expression (Amiga + 'O'):
  1531.  
  1532.     With Remove Expression, you can remove an interrupt criterion by selecting
  1533.     it from the list displayed, and clicking the 'remove' gadget.
  1534.  
  1535.   Clear All (Amiga + 'C'):
  1536.  
  1537.     Selecting this menu item removes all breakpoints and interrupt criteria.
  1538.  
  1539.  
  1540.   The Variables Menu:
  1541.  
  1542.   Show (Amiga + 'V'):
  1543.  
  1544.     With Show, you can inspect the current values of the  variables within the
  1545.     scope of a module or a procedure.  A window is opened which  allows you to
  1546.     select a  scope.   Scopes  are  identified  by  the  names  of the modules
  1547.     defining them.  The global variables of  the  current  module are called '
  1548.     Globals: Module name', and the local variables of an  active procedure are
  1549.     called 'Locals: Procedure name'.
  1550.  
  1551.     After selecting a scope, a window is opened each line  of  which shows the
  1552.     name, the value, and the type (in square brackets) of  a  variable. Values
  1553.     of structured variables cannot be  displayed  on  a  single  line, and are
  1554.     therefore  indicated  via ' ARRAY ...'  or ' RECORD ...',  respectively. A
  1555.     double-click on such  a  line  causes  a  new  window  to be  opened which
  1556.     displays the values of the array or record  elements. The  values  pointed
  1557.     to by a pointer can be inspected in a similar fashion. All  variables  the
  1558.     values of which  may  be  inspected  via  double- click are marked  by  an
  1559.     ellipsis ('...').  In this  way,  you  can  easily  work  your way through
  1560.     complex structures like trees and lists.  If a pointer has value NIL or an
  1561.     odd value, a requester with a warning is displayed.
  1562.  
  1563.     Windows displaying values of variables which are no  longer  needed may be
  1564.     closed at any time by selecting the close gadget.
  1565.  
  1566.   Extend (Amiga + 'E'):
  1567.  
  1568.     This menu item can be selected  only  if  the  active  window displays the
  1569.     contents of a RECORD.   If  this  is  an  extended  RECORD, then the  next
  1570.     extension level and the  corresponding  field  elements are  added to  the
  1571.     display window.   If  the  RECORD  is  not  extended,  or if  the type  of
  1572.     extension  cannot  be  determined  from   the   current   module,  then  a
  1573.     corresponding message is displayed.
  1574.  
  1575.   Change Value (Amiga + 'G'):
  1576.  
  1577.     Change Value allows you  to  modify  the  value  of  a previously selected
  1578.     variable.  You may specify an arbitrary expression the result of  which is
  1579.     assigned to the variable.  Of course, the result of the expression must be
  1580.     assignment compatible.
  1581.  
  1582.     You should  be  very  careful  when  changing  variable values explicitly,
  1583.     because they might lead to an unexpected program behaviour.
  1584.  
  1585.   Evaluate Expression (Amiga + 'U'):
  1586.  
  1587.     This menu item  allows  you  to  evaluate  arbitrary expressions including
  1588.     variables and constants of the module being debugged. You may  specify any
  1589.     valid Oberon expression.  However, calls to functions other  than standard
  1590.     functions are not  permitted.   You  can  use  any  standard Oberon-2 type
  1591.     (INTEGER, SET,  REAL,  BOOLEAN  etc).   The  result  and its  type will be
  1592.     displayed.
  1593.  
  1594.     Examples:
  1595.  
  1596.       a + b * 3 MOD 45 -ENTIER(a * 3.124 / b)
  1597.       (b IN (set1 * set2)) OR (node IS ExtendedNode)
  1598.       ODD(Intuition.int.activeScreen.rastport.bitMap.bytesPerRow)
  1599.  
  1600.     An erroneous expression results in a corresponding error message.
  1601.  
  1602.     Expression evaluation may be terminated by selecting the 'Cancel' gadget.
  1603.  
  1604.   Change Type (Amiga + 'Y'):
  1605.  
  1606.     It is possible to change the type of a variable, which is similar to using
  1607.     procedure VAL() of module SYSTEM.  Hence,  the  new  type should  have the
  1608.     same size as the original type.  Type modification is for display purposes
  1609.     only, though, and it does not affect the program being debugged in any way.
  1610.  
  1611.     To select a type, you must first select the scope  of  the type identifier
  1612.     in a separate window. 'Standard identifiers' denotes the standard Oberon-2
  1613.     type identifiers.  Finally, you must select the type itself.
  1614.  
  1615.   Show active Procedures (Amiga + 'P'):
  1616.  
  1617.     This function opens a window displaying the names of all  procedures which
  1618.     are currently active, ie the procedures the local  variables of  which are
  1619.     visible.
  1620.  
  1621.   Show called Procedures (Amiga + 'L'):
  1622.  
  1623.     This function opens a window displaying the names of all procedures called
  1624.     in the order in which they have been called.   A  recursion, for instance,
  1625.     can be traced back easily in this way.
  1626.  
  1627.   Save Contents:
  1628.  
  1629.     The  contents  of  a  window  displaying  variable  values   or  procedure
  1630.     identifiers may be printed or saved to an ASCII file using  this function.
  1631.     First, you are prompted for  a  file  name.   If  you  specify 'PRT:', the
  1632.     window contents are printed.  Note that the whole contents of a window are
  1633.     printed or saved, and not  just  the  currently  visible  part. Since  the
  1634.     saved file is an ASCII file,  it  may  subsequently  be  edited, or output
  1635.     using CLI command TYPE.
  1636.  
  1637.   The Options Menu:
  1638.  
  1639.   Popup Windows (Amiga + '0'):
  1640.  
  1641.     If this option  is  selected,  then  a  change  of  modules, eg  calling a
  1642.     procedure of a different module, will cause the window  of the destination
  1643.     module to be  brought  to  the  foreground.   This  is quite practical  in
  1644.     particular if several modules are being debugged at the same time.
  1645.  
  1646.   Sort RECORDs (Amiga + '1'):
  1647.  
  1648.     Selecting  this  option  results  in  RECORD  fields  being  displayed  in
  1649.     alphabetical order.  Otherwise, fields are displayed in the order in which
  1650.     they are defined.
  1651.  
  1652.   Close Pointers (Amiga + '2'):
  1653.  
  1654.     Usually, all windows  displaying  values  of  RECORDs,  ARRAYs, or  of any
  1655.     aggregate pointed to by a pointer, are closed automatically if control  is
  1656.     returned to the program being  debugged ( via  Step,  Walk etc).  This  is
  1657.     necessary because the values displayed may become invalid, eg if memory is
  1658.     released by the program.
  1659.  
  1660.     De-selecting option Close Pointers causes such windows to remain  open, so
  1661.     that you do not need to reopen them.  It is  not  guaranteed, though, that
  1662.     the values displayed are still valid.
  1663.  
  1664.   Open Sources (Amiga + '3'):
  1665.  
  1666.     If this option is disabled, then the automatic display of the source texts
  1667.     of all modules making up the program being debugged is  prevented. Rather,
  1668.     only those windows are opened which  display  statements  the execution of
  1669.     which is imminent.
  1670.  
  1671.     Disabling  this  option  is  important  for  programs  consisting  of many
  1672.     different modules, in order to avoid memory  allocation  problems.  If you
  1673.     wish to display a  source  text  not  currently  displayed,  you can still
  1674.     select Show Source from the Debug menu.
  1675.  
  1676.  
  1677. Copyright:
  1678.  
  1679.   This disk may be distributed freely without alternations, free of charge.
  1680.  
  1681.   The programs and the files on this disk may not be altered.  Altered
  1682.   versions of these programs may neither be used nor distributed.
  1683.  
  1684.   These programs may only be distributed together with this disk.  Ie it
  1685.   it is not permitted to copy and distribute just the editor, despite the
  1686.   fact that it is fully functional without the compiler.
  1687.  
  1688.   The texts by Niklaus Wirth and Hanspeter Mössenböck may be distributed on
  1689.   their own, and eg be uploaded into bulletin boards.  But they may not be
  1690.   altered, and it should be ensured by an appropriate note that they will not
  1691.   be altered.
  1692.  
  1693.   All other files are © 1989-1992 by
  1694.     Fridtjof Siebert
  1695.     Nobileweg 67
  1696.     D-7000 Stuttgart 40
  1697.     Germany
  1698.     siebert@minnie.informatik.uni-stuttgart.de
  1699.     fridi@amokst.adsp.sub.org
  1700.     2:2407/106.6
  1701.  
  1702.   Any unlawful use of these files will be prosecuted.
  1703.  
  1704.   I will always be grateful for any information on bugs in my programs.  I
  1705.   cannot guarantee that I will find time to answer all correspondence.  So
  1706.   please direct all queries to A+L AG, and don't keep me unnecessarily from
  1707.   programming. I won't answer any questions by telephone.
  1708.  
  1709.   The author will not be held liable for the correctness and functionality
  1710.   of the programs and files.  Also, the author is not liable for any damages
  1711.   incurred through the use of the programs and the files.
  1712.  
  1713.  
  1714. Full Compiler Version:
  1715.  
  1716.   The fully functional compiler version may be ordered directly from
  1717.  
  1718.      A+L AG
  1719.      Im Däderiz 61
  1720.      CH-2540 Grenchen
  1721.      Switzerland
  1722.      Phone: + 41 / 65 / 52 03 11
  1723.      Fax  : + 41 / 65 / 52 03 79
  1724.  
  1725.   in Germany, you may get the german version of the compiler and the debugger
  1726.   from
  1727.  
  1728.     ABF Computer
  1729.     Postfach 14 25
  1730.     7120 Bietigheim-Bissingen
  1731.     Germany
  1732.     Phone/Fax: + 49 / 71 42 / 3 33 92
  1733.  
  1734.   This version will be supplied with comprehensive documentation, further
  1735.   auxiliary programs, many library modules and a complete interface to
  1736.   the Amiga's system routines (version 2.04.
  1737.  
  1738.  
  1739. Contents of the commercial version:
  1740.  
  1741.   The standard package consists of the following files:
  1742.  
  1743.     Oberon               the Compiler
  1744.     OEd                  the Editor
  1745.     OLink                the Linker
  1746.     OErr                 the error lister
  1747.     OMake                the make utility
  1748.     ModToDef             tool to automatically generate definition files
  1749.     ResidentManager      tool to keep symbol files resident in memory
  1750.     LibLink              library- and device-linker. This linker allows you
  1751.                          to write Amiga-libraries and devices in Oberon-2
  1752.     GarbagePrefs         preferences editor for the garbage-collector
  1753.     GCStat               program to display the garbage-collector's activity
  1754.     sym/obj    (dir)     symbol- and objectfiles of all Amiga-interface- and
  1755.                          all
  1756.                          library-modules (altogether more than 100 modules)
  1757.     Interfaces (dir)     Source texts of all Amiga-interface-modules (more
  1758.                          than 50 modules)
  1759.     Module     (dir)     source texts of all library modules (nearly 50
  1760.                          moduls)
  1761.  
  1762.   The manual that comes with the commercial version has more than 400 pages.
  1763.  
  1764.   The debugger package includes the following programs:
  1765.  
  1766.     ODebug               the Debugger
  1767.     DecObj               a disassembler for object files and executables
  1768.     XRef                 a cross reference lister for Oberon-2
  1769.  
  1770.   Additionally, the debugger package comes with special versions of the
  1771.   compiler, editor, etc. that have been optimized for the processors MC68020
  1772.   and the FPU MC68881/2.
  1773.  
  1774.   The latest version of Amiga Oberon-2 (V3.0) is currently (december 1992)
  1775.   not available with an english manual. An english version for Amiga Oberon
  1776.   (V2.0) is available. It will hopefully be translated to english soon
  1777.   (the translation will not be done by me, so there will be fewer language
  1778.   mistakes, I hope).
  1779.  
  1780.   If you're interested in an english version, send a request to A+L. Many
  1781.   requests for the english version will probably accelerate the translation.
  1782.  
  1783.  
  1784. I hope you'll have much fun and success programming in Oberon-2!
  1785.  
  1786.  
  1787. --- Fridtjof
  1788.  
  1789.